package com.ruoyi.business.service.impl;

import com.alibaba.fastjson.JSON;
import com.ruoyi.business.domain.CarPackageAudit;
import com.ruoyi.business.domain.ServiceItem;
import com.ruoyi.business.mapper.DefinitionNodeMapper;
import com.ruoyi.business.mapper.ServiceItemMapper;
import com.ruoyi.business.service.ICarPackageAuditService;
import com.ruoyi.business.service.IDefinitionNodeService;
import com.ruoyi.business.service.IServiceItemService;
import com.ruoyi.business.service.IProcessService;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.ShiroUtils;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 养修服务项Service业务层处理
 * 
 * @author wolfcode
 * @date 2021-05-14
 */
@Service
public class ServiceItemServiceImpl implements IServiceItemService
{
    @Autowired
    private ServiceItemMapper serviceItemMapper;

    //定义处理工作流程的对象
    @Autowired
    private IProcessService processService;

    //定义审核列表mapper对象
    @Autowired
    private ICarPackageAuditService carPackageAuditService;

    @Autowired
    private DefinitionNodeMapper definitionNodeMapper;
    /**
     * 查询养修服务项
     * 
     * @param id 养修服务项ID
     * @return 养修服务项
     */
    @Override
    public ServiceItem selectServiceItemById(Long id)
    {
        return serviceItemMapper.selectServiceItemById(id);
    }

    /**
     * 查询养修服务项列表
     * 
     * @param serviceItem 养修服务项
     * @return 养修服务项
     */
    @Override
    public List<ServiceItem> selectServiceItemList(ServiceItem serviceItem)
    {
        return serviceItemMapper.selectServiceItemList(serviceItem);
    }

    /**
     * 新增养修服务项
     * 
     * @param serviceItem 养修服务项
     * @return 结果
     */
    @Override
    public int insertServiceItem(ServiceItem serviceItem)
    {
        serviceItem.setCreateTime(DateUtils.getNowDate());
        if(ServiceItem.CARPACKAGE_YES.equals(serviceItem.getCarPackage())){
            serviceItem.setAuditStatus(ServiceItem.AUDITSTATUS_INIT);//设置初始化
        }
        return serviceItemMapper.insertServiceItem(serviceItem);
    }

    /**
     * 修改养修服务项
     * 
     * @param serviceItem 养修服务项
     * @return 结果
     */
    @Override
    public int updateServiceItem(ServiceItem serviceItem)
    {
        ServiceItem oldObj = selectServiceItemById(serviceItem.getId());
        //处于上架状态的商品不能修改
        if(ServiceItem.SALESTATUS_ON.equals(oldObj.getSaleStatus())){
            throw new BusinessException("上架服务项目不能修改，请下架后再修改");
        }else if(ServiceItem.AUDITSTATUS_AUDITING.equals(oldObj.getAuditStatus())){
            throw new BusinessException("服务项目正在审核中,不可修改");
        }
        //如果是审核通过，此时修改，需要将其状态变更为初始化
        if(ServiceItem.AUDITSTATUS_APPROVED.equals(oldObj.getAuditStatus())){
            serviceItem.setAuditStatus(ServiceItem.AUDITSTATUS_INIT);
        }
        serviceItem.setVersion(oldObj.getVersion());
        return serviceItemMapper.updateServiceItem(serviceItem);
    }
    /**
     * 删除养修服务项对象
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteServiceItemByIds(String ids)
    {
        return serviceItemMapper.deleteServiceItemByIds(Convert.toStrArray(ids));
    }
    /**
     * 下架
     *
     * @param id 需要下架的服务项ID
     * @return
     */
    @Override
    public int saleOff(Long id) {
        return serviceItemMapper.changeSaleStatus(id,ServiceItem.SALESTATUS_OFF);
    }
    /**
     * 上架
     * @param id 需要上架的服务ID
     * @return
     */
    @Override
    public int saleOn(Long id) {
        ServiceItem serviceItem = selectServiceItemById(id);
        //如果不是套餐，可以直接上架
        //如果是套餐，只有审核成功才能上架
        if(ServiceItem.CARPACKAGE_YES.equals(serviceItem.getCarPackage())
                && !ServiceItem.AUDITSTATUS_APPROVED.equals(serviceItem.getAuditStatus())){
            throw new BusinessException("套餐服务项需要审核通过之后才能上架");
        }
        return serviceItemMapper.changeSaleStatus(id,ServiceItem.SALESTATUS_ON);
    }
    /**
     * 查询上家的养修服务项列表
     *
     * @param serviceItem 养修服务项
     * @return 养修服务项集合
     */
    @Override
    public List<ServiceItem> selectAllSaleOnList(ServiceItem serviceItem) {
        return serviceItemMapper.selectAllSaleOnList(serviceItem);
    }

    @Override
    @Transactional
    public int selectCarPackageAudit(Long id) {
        /*
        * 1.根据ID查询养修服务项
    2.判断养修服务项的状态(只有审核状态为初始化才能发起审核)
    3.更新养修服务项状态为审核中.
    4.插入审核列表信息
    5.启动流程实例(把参数携带过去)
    6.根据节点设置处理人
    7.更新审核列表信息(审核人名称集合,流程实例ID)*/
        ServiceItem serviceItem  = serviceItemMapper.selectServiceItemById(id);
        if(ServiceItem.CARPACKAGE_NO.equals(serviceItem.getCarPackage())){
            throw new BusinessException("该服务项不是套餐不需要进行审核");
        }
        if(!ServiceItem.AUDITSTATUS_INIT.equals(serviceItem.getAuditStatus()))
        {
            throw new BusinessException("套餐服务项需要为初始化时才可以进行审核");
        }
        serviceItem.setAuditStatus(serviceItem.AUDITSTATUS_AUDITING);
        serviceItemMapper.updateServiceItem(serviceItem);
        CarPackageAudit carPackageAudit = new CarPackageAudit();
        carPackageAudit.setCreateBy(ShiroUtils.getUserId().toString());
        carPackageAudit.setServiceItemInfo(JSON.toJSONString(serviceItem));
        carPackageAuditService.insertCarPackageAudit(carPackageAudit);
        //启动流程
        //获取业务标识
        String packageKey = carPackageAudit.getId().toString();
        Map<String ,Object> map = new HashMap<>();
        map.put("money",serviceItem.getDiscountPrice().longValue());
        ProcessInstance processInstance = processService.deployByCarPackAgeAuditKey(CarPackageAudit.DEFINITION_KEY,packageKey,map);
        Task task = processService.taskNameByProcessInstanceId(processInstance);
        //获取key
        String taskDefinitionKey = task.getTaskDefinitionKey();
        List<SysUser> users = definitionNodeMapper.selectSysUserNameByNodeKey(taskDefinitionKey);
        //给节点设置候选人
        List<String> userName = new ArrayList<>();
        for (SysUser user : users) {
            processService.addUser(task,user.getUserId());
            userName.add(user.getUserName());
        }
        carPackageAudit.setProcessDefinitionId(processInstance.getProcessDefinitionId());
        carPackageAudit.setAuditors(JSON.toJSONString(userName));
        carPackageAudit.setInstanceId(task.getProcessInstanceId());
        carPackageAuditService.updateCarPackageAudit(carPackageAudit);
        return 1;
    }

}
